package main.leetcode.clockin.Auguest;

import main.datastruc.TreeNode;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 114. 二叉树展开为链表
 *
 * <p>给定一个二叉树，原地将它展开为一个单链表。
 */
public class day2 {
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    private TreeNode pre;

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //        new day2().flatten(TreeNode.creCmpBTree(new int[] {1, 2, 3}));

        //        CompletableFuture<Integer> future =
        //                CompletableFuture.supplyAsync(
        //                                () -> {
        //                                    System.out.println("当前线程：" +
        // Thread.currentThread().getId());
        //                                    int i = 10 / 0;
        //                                    System.out.println("运行结果：" + i);
        //                                    return i;
        //                                },
        //                                executor)
        //                        // 执行完毕的回调
        //                        .whenComplete(
        //                                (integer, throwable) -> {
        //                                    System.out.println(
        //                                            "异步任务执行完成，结果：" + integer + "异常：" + throwable);
        //                                })
        //                        // 出现异常的回调
        //                        .exceptionally(throwable -> 10);

        //        CompletableFuture<Integer> future =
        //                CompletableFuture.supplyAsync(
        //                                () -> {
        //                                    return 1;
        //                                },
        //                                executor)
        //                        // 执行完毕的回调
        //                        .thenApplyAsync(
        //                                integer -> {
        //                                    return integer + 2;
        //                                },
        //                                executor);
        //        System.out.println("end --- " + future.get());

        CompletableFuture<Integer> future1 =
                CompletableFuture.supplyAsync(
                        () -> {
                            System.out.println("任务1执行：" + Thread.currentThread().getId());
                            return 1;
                        },
                        executor);

        CompletableFuture<Integer> future2 =
                CompletableFuture.supplyAsync(
                        () -> {
                            System.out.println("任务2执行：" + Thread.currentThread().getId());
                            return 2;
                        },
                        executor);

        // 不可以接收前两个任务的结果
        //        future1.runAfterBothAsync(
        //                future2,
        //                () -> {
        //                    System.out.println("任务3执行：" + Thread.currentThread().getId());
        //                },
        //                executor);

        // 可以接收前两个任务的结果
        //        future1.thenAcceptBothAsync(
        //                future2,
        //                (integer, integer2) -> {
        //                    System.out.println("任务3执行：" + (integer + integer2));
        //                },
        //                executor);
        //        System.out.println("end");

        // 或者这样
        future1.thenCombineAsync(
                future2,
                (integer, integer2) -> {
                    System.out.println("任务3执行：" + (integer + integer2));
                    return 3;
                },
                executor);

        // 阻塞，等待所有任务执行完成
        //      anyOf，任意一个执行完毕
        CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);
        allOf.get();

        // 只要有一个完成就执行任务3
        //      future1.runAfterEitherAsync()
        System.out.println("end" + future1.get());
    }

    public void flatten(TreeNode root) {
        if (root == null) {
            return;
        }
        // 二叉树反中序 相当于 链表自底向上
        flatten(root.right);
        flatten(root.left);
        root.right = pre;
        root.left = null;
        pre = root;
    }
}
